home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / WWBBSSrc / node.c < prev    next >
C/C++ Source or Header  |  1995-06-25  |  9KB  |  334 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <libraries/wwbbs.h>
  4. #include <ctype.h>
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8.  
  9. #include "wwbbs.h"
  10.  
  11. #include "wwbbs_settings.h"
  12.  
  13. #include "wwbbs_lib.h"
  14.  
  15. #include "node_lib.h"
  16.  
  17. #include "libs.h"
  18.  
  19. #include "Data:Programs/Include/wwbbs_commands.h"
  20.  
  21. BOOL __saveds GetModemResult(struct Libraries *,BYTE *,char **,char *,long);
  22. BOOL __saveds GetModemResultWait(struct Libraries *,BYTE *,char **,char *,long);
  23. int __saveds SerialRead(struct Libraries *,BYTE *,char *,long,long,long);
  24.  
  25. LONG __saveds NodeProc()
  26.     {
  27.         struct ConfirmationMessage *msg;
  28.         struct CommandMessage *qmsg=NULL;
  29.         struct Process *proc;
  30.         proc=(struct Process *) FindTask(NULL);
  31.         WaitPort(&proc->pr_MsgPort);
  32.         if(msg=(struct ConfirmationMessage *) GetMsg(&proc->pr_MsgPort))
  33.             {
  34.                 BYTE name[64],id[33];
  35.                 struct MsgPort *port;
  36.                 BOOL ok=TRUE;
  37.                 strcpy(id,msg->cm_ID);
  38.                 sprintf(name,"WWBBS Node.%s",id);
  39.                 if(!(port=CreatePort(name,0)))
  40.                     ok=FALSE;
  41.                 msg->cm_Return=ok;
  42.                 ReplyMsg((struct Message *) msg);
  43.                 if(ok)
  44.                     {
  45.                         struct Libraries *libs;
  46.                         if(libs=OpenLibraries())
  47.                             {
  48.                                 BOOL node_autobaud=FALSE;
  49.                                 GetConfigTags(CFGTAG_Path,"Nodes",CFGTAG_Name,id,NDTAG_AutoBaud,&node_autobaud,TAG_END);
  50.                                 if(StartProcess("WWBBS Serial",SerialProc,20000,id))
  51.                                     {
  52.                                         BOOL kg=TRUE;
  53.                                         while(kg)
  54.                                             {
  55.                                                 if(SerialCommandTags(id,SERCMD_Open,TAG_END))
  56.                                                     {
  57.                                                         /* Check carrier, if present hang up... */
  58.                                                         {
  59.                                                             char *matchstring[]={"OK",NULL};
  60.                                                             if(SerialCommandTags(id,SERCMD_Carrier,TAG_END))
  61.                                                                 {
  62.                                                                     SerialCommandTags(id,SERCMD_Write,
  63.                                                                         SERWRITETAG_Buffer,"+++",
  64.                                                                         SERWRITETAG_Size,-1,
  65.                                                                         TAG_END);
  66.                                                                     GetModemResult(libs,id,matchstring,NULL,5000000);
  67.                                                                     SerialCommandTags(id,SERCMD_Write,
  68.                                                                         SERWRITETAG_Buffer,"ATH\r",
  69.                                                                         SERWRITETAG_Size,-1,
  70.                                                                         TAG_END);
  71.                                                                     GetModemResult(libs,id,matchstring,NULL,5000000);
  72.                                                                 }
  73.                                                             SerialCommandTags(id,SERCMD_SetBaud,SERSETBAUDTAG_ResetBaud,TRUE,TAG_END);
  74.                                                             SerialCommandTags(id,SERCMD_Write,
  75.                                                                 SERWRITETAG_Buffer,"ATZ\r",
  76.                                                                 SERWRITETAG_Size,-1,
  77.                                                                 TAG_END);
  78.                                                             GetModemResult(libs,id,matchstring,NULL,5000000);
  79.                                                         }
  80.  
  81.                                                         /* Wait if no carrier present... */
  82.                                                         if(!SerialCommandTags(id,SERCMD_Carrier,TAG_END))
  83.                                                             {
  84.                                                                 BOOL kg2=TRUE;
  85.                                                                 char *matchstring[]={"RING","CONNECT",NULL};
  86.                                                                 char buff[256];
  87.                                                                 while(kg && kg2)
  88.                                                                     {
  89.                                                                         if(GetModemResultWait(libs,id,matchstring,buff,1 << port->mp_SigBit))
  90.                                                                             {
  91.                                                                                 if(!strncmp(buff,"RING",4))
  92.                                                                                     SerialCommandTags(id,SERCMD_Write,
  93.                                                                                         SERWRITETAG_Buffer,"ATA\r",
  94.                                                                                         SERWRITETAG_Size,-1,
  95.                                                                                         TAG_END);
  96.                                                                                 if(!strncmp(buff,"CONNECT",7))
  97.                                                                                     {
  98.                                                                                         ULONG baud=0;
  99.                                                                                         {
  100.                                                                                             char *p;
  101.                                                                                             if(p=strchr(buff,'\r'))
  102.                                                                                                 *p=NULL;
  103.                                                                                             if(p=strchr(buff,'\n'))
  104.                                                                                                 *p=NULL;
  105.                                                                                         }
  106.                                                                                         if(!strcmp(buff,"CONNECT"))
  107.                                                                                             baud=300;
  108.                                                                                         else
  109.                                                                                             baud=atol(&buff[8]);
  110.                                                                                         if(node_autobaud && baud)
  111.                                                                                             SerialCommandTags(id,SERCMD_SetBaud,SERSETBAUDTAG_NewBaud,baud,TAG_END);
  112.                                                                                         Session(libs,id,FALSE,baud);
  113.                                                                                         kg2=FALSE;
  114.                                                                                     }
  115.                                                                             }
  116.                                                                         {
  117.                                                                             struct CommandMessage *msg;
  118.                                                                             while(kg && kg2 && (msg=(struct CommandMessage *) GetMsg(port)))
  119.                                                                                 {
  120.                                                                                     msg->cm_Data=NULL;
  121.                                                                                     switch(msg->cm_Command)
  122.                                                                                         {
  123.                                                                                             case NDCMD_Quit:
  124.                                                                                                 msg->cm_Data=TRUE;
  125.                                                                                                 qmsg=msg;
  126.                                                                                                 kg2=FALSE;
  127.                                                                                                 kg=FALSE;
  128.                                                                                                 break;
  129.                                                                                         }
  130.                                                                                     if(!qmsg)
  131.                                                                                         ReplyMsg((struct Message *) msg);
  132.                                                                                 }
  133.                                                                         }
  134.                                                                     }
  135.                                                             }
  136.                                                         SerialCommandTags(id,SERCMD_Close,TAG_END);
  137.                                                         Delay(50L);
  138.                                                     }
  139.                                                 else
  140.                                                     {
  141.                                                         WaitPort(port);
  142.                                                         {
  143.                                                             struct CommandMessage *msg;
  144.                                                             while(kg && (msg=(struct CommandMessage *) GetMsg(port)))
  145.                                                                 {
  146.                                                                     msg->cm_Data=NULL;
  147.                                                                     switch(msg->cm_Command)
  148.                                                                         {
  149.                                                                             case NDCMD_Quit:
  150.                                                                                 msg->cm_Data=TRUE;
  151.                                                                                 qmsg=msg;
  152.                                                                                 kg=FALSE;
  153.                                                                                 break;
  154.                                                                         }
  155.                                                                     if(!qmsg)
  156.                                                                         ReplyMsg((struct Message *) msg);
  157.                                                                 }
  158.                                                         }
  159.                                                     }
  160.                                             }
  161.                                         KillProcess("WWBBS Serial",id);
  162.                                     }
  163.                                 CloseLibraries(libs);
  164.                             }
  165.                         DeletePort(port);
  166.                     }
  167.             }
  168.         if(qmsg)
  169.             {
  170.                 Forbid();
  171.                 ReplyMsg((struct Message *) qmsg);
  172.             }
  173.         return(0);
  174.     }
  175.  
  176. BOOL __saveds GetModemResult(struct Libraries *libs,BYTE *id,char **matchstring,char *destbuff,long timeout)
  177.     {
  178.         char buffer[256];
  179.         int len,kg=TRUE;
  180.         BOOL ret=FALSE;
  181.         while(kg)
  182.             {
  183.                 if(len=SerialRead(libs,id,buffer,255,timeout,NULL))
  184.                     {
  185.                         int count;
  186.                         while(1)
  187.                             {
  188.                                 if(len==255)
  189.                                     break;
  190.                                 count=SerialRead(libs,id,&buffer[len],255-len,500000,NULL);
  191.                                 if(!count)
  192.                                     break;
  193.                                 len+=count;
  194.                             }
  195.                     }
  196.                 if(len)
  197.                     {
  198.                         int i,j;
  199.                         buffer[len]=NULL;
  200.                         for(i=0;i<strlen(buffer);i++)
  201.                             {
  202.                                 for(j=0;matchstring[j];j++)
  203.                                     {
  204.                                         if(!strncmp(&buffer[i],matchstring[j],strlen(matchstring[j])))
  205.                                             {
  206.                                                 if(destbuff)
  207.                                                     strcpy(destbuff,&buffer[i]);
  208.                                                 ret=TRUE;
  209.                                                 kg=FALSE;
  210.                                             }
  211.                                         if(!kg)
  212.                                             break;
  213.                                     }
  214.                                 if(!kg)
  215.                                     break;
  216.                             }
  217.                     }
  218.                 else
  219.                     kg=FALSE;
  220.             }
  221.         return(ret);
  222.     }
  223.  
  224. BOOL __saveds GetModemResultWait(struct Libraries *libs,BYTE *id,char **matchstring,char *destbuff,long mask)
  225.     {
  226.         char buffer[256];
  227.         int len,kg=TRUE;
  228.         BOOL ret=FALSE;
  229.         while(kg)
  230.             {
  231.                 if(len=SerialRead(libs,id,buffer,255,NULL,mask))
  232.                     {
  233.                         int count;
  234.                         while(1)
  235.                             {
  236.                                 if(len==255)
  237.                                     break;
  238.                                 count=SerialRead(libs,id,&buffer[len],255-len,500000,NULL);
  239.                                 if(!count)
  240.                                     break;
  241.                                 len+=count;
  242.                             }
  243.                     }
  244.                 if(len)
  245.                     {
  246.                         int i,j;
  247.                         buffer[len]=NULL;
  248.                         for(i=0;i<strlen(buffer);i++)
  249.                             {
  250.                                 for(j=0;matchstring[j];j++)
  251.                                     {
  252.                                         if(!strncmp(&buffer[i],matchstring[j],strlen(matchstring[j])))
  253.                                             {
  254.                                                 if(destbuff)
  255.                                                     strcpy(destbuff,&buffer[i]);
  256.                                                 ret=TRUE;
  257.                                                 kg=FALSE;
  258.                                             }
  259.                                         if(!kg)
  260.                                             break;
  261.                                     }
  262.                                 if(!kg)
  263.                                     break;
  264.                             }
  265.                     }
  266.                 else
  267.                     kg=FALSE;
  268.             }
  269.         return(ret);
  270.     }
  271.  
  272. int __saveds SerialRead(struct Libraries *libs,BYTE *id,char *buffer,long size,long timeout,long waitmask)
  273.     {
  274.         ULONG mask;
  275.         int ret=0;
  276.         ret=SerialCommandTags(id,SERCMD_Read,
  277.                     SERREADTAG_Buffer,buffer,
  278.                     SERREADTAG_Size,size,
  279.                     TAG_END);
  280.         if(!ret)
  281.             {
  282.                 if(waitmask)
  283.                     ret=SerialCommandTags(id,SERCMD_Wait,
  284.                                 SERWAITTAG_WaitMask,waitmask,
  285.                                 SERWAITTAG_WaitMaskRet,&mask,
  286.                                 SERWAITTAG_Buffer,buffer,
  287.                                 SERWAITTAG_Size,size,
  288.                                 TAG_END);
  289.                 else
  290.                     {
  291.                         struct MsgPort *TimerMP;
  292.                         struct timerequest *TimerIO;
  293.                         if(TimerMP=CreateMsgPort())
  294.                             {
  295.                                 if(TimerIO=(struct timerequest *) CreateIORequest(TimerMP,sizeof(struct timerequest)))
  296.                                     {
  297.                                         if(!OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *) TimerIO,0))
  298.                                             {
  299.                                                 TimerIO->tr_node.io_Command=TR_ADDREQUEST;
  300.                                                 TimerIO->tr_time.tv_secs=timeout/1000000;
  301.                                                 TimerIO->tr_time.tv_micro=timeout%1000000;
  302.                                                 SendIO((struct IORequest *) TimerIO);
  303.                                                 {
  304.                                                     BOOL kg=TRUE;
  305.                                                     while(kg)
  306.                                                         {
  307.                                                             ret=SerialCommandTags(id,SERCMD_Wait,
  308.                                                                         SERWAITTAG_WaitMask,(1 << TimerMP->mp_SigBit) | waitmask,
  309.                                                                         SERWAITTAG_WaitMaskRet,&mask,
  310.                                                                         SERWAITTAG_Buffer,buffer,
  311.                                                                         SERWAITTAG_Size,size,
  312.                                                                         TAG_END);
  313.                                                             if(ret)
  314.                                                                 kg=FALSE;
  315.                                                             if(CheckIO((struct IORequest *) TimerIO))
  316.                                                                 kg=FALSE;
  317.                                                             if(mask)
  318.                                                                 kg=FALSE;
  319.                                                         }
  320.                                                 }
  321.                                                 if(!CheckIO((struct IORequest *) TimerIO))
  322.                                                     AbortIO((struct IORequest *) TimerIO);
  323.                                                 WaitIO((struct IORequest *) TimerIO);
  324.                                                 CloseDevice((struct IORequest *) TimerIO);
  325.                                             }
  326.                                         DeleteIORequest((struct IORequest *) TimerIO);
  327.                                     }
  328.                                 DeleteMsgPort(TimerMP);
  329.                             }
  330.                     }
  331.             }
  332.         return(ret);
  333.     }
  334.